package com.jr.service.impl;

import com.jr.mapper.ParkingRecordsMapper;
import com.jr.mapper.ParkingSpacesMapper;
import com.jr.mapper.TempEntryMapper;
import com.jr.mapper.VehiclesMapper;
import com.jr.pojo.ParkingRecords;
import com.jr.pojo.Vehicles;
import com.jr.service.TempEntryService;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * 临时车位入口管理服务实现类
 */
@Service
public class TempEntryServiceImpl implements TempEntryService {
    
    @Resource
    private TempEntryMapper tempEntryMapper;
    
    @Resource
    private ParkingSpacesMapper parkingSpacesMapper;
    
    @Resource
    private VehiclesMapper vehiclesMapper;
    
    @Resource
    private ParkingRecordsMapper parkingRecordsMapper;
    
    // 用于存储已经返回过的id，避免重复返回
    private final Set<Integer> returnedIds = new HashSet<>();
    
    /**
     * 查询status=0且space=0的临时空闲车位数量
     * @return 符合条件的车位数量
     */
    @Override
    public Integer countAvailableTempSpaces() {
        // 清理已不满足条件的id（可以在实际业务中定期清理）
        // 在实际生产环境中，建议使用Redis或其他持久化存储来跟踪已返回的id
        // 并通过定时任务或其他机制清理不再满足条件的id
        
        return tempEntryMapper.countAvailableTempSpaces();
    }
    
    /**
     * 查询status=0且space=0的随机一个临时空闲车位的code和id（不重复返回相同id）
     * @return 包含code和id的Map对象，如果没有可用车位则返回null
     */
    @Override
    public Map<String, Object> findRandomAvailableTempSpace() {
        // 获取所有可用车位数量
        Integer availableCount = countAvailableTempSpaces();
        
        // 如果没有可用车位或所有可用车位都已返回过，则返回null
        if (availableCount == null || availableCount == 0 || availableCount <= returnedIds.size()) {
            // 清空已返回的id集合，重新开始
            returnedIds.clear();
            
            // 再次检查是否有可用车位
            availableCount = countAvailableTempSpaces();
            if (availableCount == null || availableCount == 0) {
                return null;
            }
        }
        
        // 循环查找未返回过的随机可用车位
        while (true) {
            Map<String, Object> result = tempEntryMapper.findRandomAvailableTempSpace();
            if (result == null || !result.containsKey("id")) {
                return null;
            }
            
            Integer id = (Integer) result.get("id");
            
            // 如果该id未返回过，则添加到已返回集合并返回结果
            if (!returnedIds.contains(id)) {
                returnedIds.add(id);
                return result;
            }
            
            // 如果已返回的id数量等于可用车位数量，说明所有可用车位都已返回过
            if (returnedIds.size() >= availableCount) {
                // 清空已返回的id集合，重新开始
                returnedIds.clear();
            }
        }
    }
    
    /**
     * 同时执行车位状态更新、车辆信息插入和停车记录插入的事务操作
     * @param parkingRecords 停车记录对象
     * @param vehicles 车辆信息对象
     * @param id 车位id
     * @return 操作是否成功
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean createTempEntry(ParkingRecords parkingRecords, Vehicles vehicles, Integer id) {
        try {
            // 1. 插入车辆信息并获取自增id
            Integer vehicleId = vehiclesMapper.insertVehicle(vehicles);
            if (vehicleId == null || vehicleId <= 0) {
                return false;
            }
            
            // 2. 将获取到的vehicleId设置到parkingRecords对象中
            parkingRecords.setVehicleId(vehicleId);
            
            // 3. 插入停车记录
            Integer parkingRecordId = parkingRecordsMapper.insertParkingRecord(parkingRecords);
            if (parkingRecordId == null || parkingRecordId <= 0) {
                return false;
            }
            
            // 4. 更新车位状态为占用(1)
            Integer updatedCount = parkingSpacesMapper.updateStatusById(id);
            if (updatedCount == null || updatedCount != 1) {
                return false;
            }
            
            return true;
        } catch (Exception e) {
            // 发生异常时，事务会自动回滚
            return false;
        }
    }
}